home *** CD-ROM | disk | FTP | other *** search
/ Hot Super Models / Hot Super Models.iso / unix / x11 / xv2r1.tar / xv2r1 / extensions / xv / server / xvdisp.c < prev    next >
C/C++ Source or Header  |  1991-06-11  |  28KB  |  1,261 lines
  1. /***********************************************************
  2. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  3. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Digital or MIT not be
  12. used in advertising or publicity pertaining to distribution of the
  13. software without specific, written prior permission.  
  14.  
  15. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21. SOFTWARE.
  22.  
  23. ******************************************************************/
  24. /*
  25. ** File: 
  26. **
  27. **   xvdisp.c --- Xv server extension dispatch module.
  28. **
  29. ** Author: 
  30. **
  31. **   David Carver (Digital Workstation Engineering/Project Athena)
  32. **
  33. ** Revisions:
  34. **
  35. **   11.06.91 Carver
  36. **     - changed SetPortControl to SetPortAttribute
  37. **     - changed GetPortControl to GetPortAttribute
  38. **     - changed QueryBestSize
  39. **
  40. **   15.05.91 Carver
  41. **     - version 2.0 upgrade
  42. **
  43. **   24.01.91 Carver
  44. **     - version 1.4 upgrade
  45. **
  46. */
  47.  
  48. #include <stdio.h>
  49.  
  50. #include "X.h"
  51. #include "Xproto.h"
  52. #include "misc.h"
  53. #include "scrnintstr.h"
  54. #include "windowstr.h"
  55. #include "pixmapstr.h"
  56. #include "gcstruct.h"
  57. #include "dixstruct.h"
  58. #include "resource.h"
  59. #include "opaque.h"
  60.  
  61. #include "Xv.h"
  62. #include "Xvproto.h"
  63. #include "xvdix.h"
  64.  
  65. /* EXTERNAL */
  66.  
  67. extern void (* ReplySwapVector[256]) ();
  68.  
  69. /* INTERNAL */
  70.  
  71. static int ProcXvQueryExtension();
  72. static int ProcXvQueryAdaptors();
  73. static int ProcXvQueryEncodings();
  74. static int ProcXvPutVideo();
  75. static int ProcXvPutStill();
  76. static int ProcXvGetVideo();
  77. static int ProcXvGetStill();
  78. static int ProcXvGrabPort();
  79. static int ProcXvUngrabPort();
  80. static int ProcXvSelectVideoNotify();
  81. static int ProcXvSelectPortNotify();
  82. static int ProcXvStopVideo();
  83. static int ProcXvSetPortAttribute();
  84. static int ProcXvGetPorAttribute();
  85. static int ProcXvQueryBestSize();
  86.  
  87. static int SProcXvQueryExtension();
  88. static int SProcXvQueryAdaptors();
  89. static int SProcXvQueryEncodings();
  90. static int SProcXvPutVideo();
  91. static int SProcXvPutStill();
  92. static int SProcXvGetVideo();
  93. static int SProcXvGetStill();
  94. static int SProcXvGrabPort();
  95. static int SProcXvUngrabPort();
  96. static int SProcXvSelectVideoNotify();
  97. static int SProcXvSelectPortNotify();
  98. static int SProcXvStopVideo();
  99. static int SProcXvSetPortAttribute();
  100. static int SProcXvGetPortAttribute();
  101. static int SProcXvQueryBestSize();
  102.  
  103. static int SWriteQueryVideoReply();
  104. static int SWriteAdaptorInfo();
  105. static int SWriteEncodingInfo();
  106. static int SWriteFormat();
  107. static int SWriteGrabPortReply();
  108. static int SWriteGetPortAttributeReply();
  109. static int SWriteQueryBestSizeReply();
  110.  
  111. #define _WriteQueryAdaptorsReply(_c,_d) \
  112.   if ((_c)->swapped) SWriteQueryAdaptorsReply(_c, _d); \
  113.   else WriteToClient(_c, sz_xvQueryAdaptorsReply, _d)
  114.  
  115. #define _WriteQueryExtensionReply(_c,_d) \
  116.   if ((_c)->swapped) SWriteQueryExtensionReply(_c, _d); \
  117.   else WriteToClient(_c, sz_xvQueryExtensionReply, _d)
  118.  
  119. #define _WriteQueryEncodingsReply(_c,_d) \
  120.   if ((_c)->swapped) SWriteQueryEncodingsReply(_c, _d); \
  121.   else WriteToClient(_c, sz_xvQueryEncodingsReply, _d)
  122.  
  123. #define _WriteAdaptorInfo(_c,_d) \
  124.   if ((_c)->swapped) SWriteAdaptorInfo(_c, _d); \
  125.   else WriteToClient(_c, sz_xvAdaptorInfo, _d)
  126.  
  127. #define _WriteEncodingInfo(_c,_d) \
  128.   if ((_c)->swapped) SWriteEncodingInfo(_c, _d); \
  129.   else WriteToClient(_c, sz_xvEncodingInfo, _d)
  130.  
  131. #define _WriteFormat(_c,_d) \
  132.   if ((_c)->swapped) SWriteFormat(_c, _d); \
  133.   else WriteToClient(_c, sz_xvFormat, _d)
  134.  
  135. #define _WriteGrabPortReply(_c,_d) \
  136.   if ((_c)->swapped) SWriteGrabPortReply(_c, _d); \
  137.   else WriteToClient(_c, sz_xvGrabPortReply, _d)
  138.  
  139. #define _WriteGetPortAttributeReply(_c,_d) \
  140.   if ((_c)->swapped) SWriteGetPortAttributeReply(_c, _d); \
  141.   else WriteToClient(_c, sz_xvGetPortAttributeReply, _d)
  142.  
  143. #define _WriteQueryBestSizeReply(_c,_d) \
  144.   if ((_c)->swapped) SWriteQueryBestSizeReply(_c, _d); \
  145.   else WriteToClient(_c, sz_xvQueryBestSizeReply, _d)
  146.  
  147. #define _AllocatePort(_i,_p) \
  148.   ((_p)->id != _i) ? (* (_p)->pAdaptor->ddAllocatePort)(_i,_p,&_p) : Success
  149.  
  150. /*
  151. ** ProcXvDispatch
  152. **
  153. **
  154. **
  155. */
  156.  
  157. int
  158. ProcXvDispatch(client)
  159. register ClientPtr client;
  160. {
  161.   REQUEST(xReq);
  162.  
  163.   UpdateCurrentTime();
  164.  
  165.   switch (stuff->data) 
  166.     {
  167.     case xv_QueryExtension: return(ProcXvQueryExtension(client));
  168.     case xv_QueryAdaptors: return(ProcXvQueryAdaptors(client));
  169.     case xv_QueryEncodings: return(ProcXvQueryEncodings(client));
  170.     case xv_PutVideo: return(ProcXvPutVideo(client));
  171.     case xv_PutStill: return(ProcXvPutStill(client));
  172.     case xv_GetVideo: return(ProcXvGetVideo(client));
  173.     case xv_GetStill: return(ProcXvGetStill(client));
  174.     case xv_GrabPort: return(ProcXvGrabPort(client));
  175.     case xv_UngrabPort: return(ProcXvUngrabPort(client));
  176.     case xv_SelectVideoNotify: return(ProcXvSelectVideoNotify(client));
  177.     case xv_SelectPortNotify: return(ProcXvSelectPortNotify(client));
  178.     case xv_StopVideo: return(ProcXvStopVideo(client));
  179.     case xv_SetPortAttribute: return(ProcXvSetPortAttribute(client));
  180.     case xv_GetPortAttribute: return(ProcXvGetPortAttribute(client));
  181.     case xv_QueryBestSize: return(ProcXvQueryBestSize(client));
  182.     default:
  183.       if (stuff->data < xvNumRequests)
  184.     {
  185.       SendErrorToClient(client, XvReqCode, stuff->data, 0, 
  186.                 BadImplementation);
  187.       return(BadImplementation);
  188.     }
  189.       else
  190.     {
  191.       SendErrorToClient(client, XvReqCode, stuff->data, 0, BadRequest);
  192.       return(BadRequest);
  193.     }
  194.     }
  195. }
  196.  
  197. int
  198. SProcXvDispatch(client)
  199. register ClientPtr client;
  200. {
  201.   REQUEST(xReq);
  202.  
  203.   UpdateCurrentTime();
  204.  
  205.   switch (stuff->data) 
  206.     {
  207.     case xv_QueryExtension: return(SProcXvQueryExtension(client));
  208.     case xv_QueryAdaptors: return(SProcXvQueryAdaptors(client));
  209.     case xv_QueryEncodings: return(SProcXvQueryEncodings(client));
  210.     case xv_PutVideo: return(SProcXvPutVideo(client));
  211.     case xv_PutStill: return(SProcXvPutStill(client));
  212.     case xv_GetVideo: return(SProcXvGetVideo(client));
  213.     case xv_GetStill: return(SProcXvGetStill(client));
  214.     case xv_GrabPort: return(SProcXvGrabPort(client));
  215.     case xv_UngrabPort: return(SProcXvUngrabPort(client));
  216.     case xv_SelectVideoNotify: return(SProcXvSelectVideoNotify(client));
  217.     case xv_SelectPortNotify: return(SProcXvSelectPortNotify(client));
  218.     case xv_StopVideo: return(SProcXvStopVideo(client));
  219.     case xv_SetPortAttribute: return(SProcXvSetPortAttribute(client));
  220.     case xv_GetPortAttribute: return(SProcXvGetPortAttribute(client));
  221.     case xv_QueryBestSize: return(SProcXvQueryBestSize(client));
  222.     default:
  223.       if (stuff->data < xvNumRequests)
  224.     {
  225.       SendErrorToClient(client, XvReqCode, stuff->data, 0, 
  226.                 BadImplementation);
  227.       return(BadImplementation);
  228.     }
  229.       else
  230.     {
  231.       SendErrorToClient(client, XvReqCode, stuff->data, 0, BadRequest);
  232.       return(BadRequest);
  233.     }
  234.     }
  235. }
  236.  
  237. static int
  238. ProcXvQueryExtension(client)
  239. register ClientPtr client;
  240.  
  241. {
  242.   xvQueryExtensionReply rep;
  243.   REQUEST(xvQueryExtensionReq);
  244.   REQUEST_SIZE_MATCH(xvQueryExtensionReq);
  245.  
  246.   rep.type = X_Reply;
  247.   rep.sequenceNumber = client->sequence;
  248.   rep.version = XvVersion;
  249.   rep.revision = XvRevision;
  250.  
  251.   _WriteQueryExtensionReply(client, &rep);
  252.  
  253.   return Success;
  254.  
  255. }
  256.  
  257. static int
  258. ProcXvQueryAdaptors(client)
  259. register ClientPtr client;
  260.  
  261. {
  262.   xvFormat format;
  263.   xvEncodingInfo einfo;
  264.   xvAdaptorInfo ainfo;
  265.   xvQueryAdaptorsReply rep;
  266.   int totalSize;
  267.   int na;
  268.   XvAdaptorPtr pa;
  269.   int nf;
  270.   XvFormatPtr pf;
  271.   WindowPtr pWin;
  272.   ScreenPtr pScreen;
  273.   XvScreenPtr pxvs;
  274.  
  275.   REQUEST(xvQueryAdaptorsReq);
  276.   REQUEST_SIZE_MATCH(xvQueryAdaptorsReq);
  277.  
  278.   if(!(pWin = (WindowPtr)LookupWindow(stuff->window, client) ))
  279.     {
  280.       client->errorValue = stuff->window;
  281.       return (BadWindow);
  282.     }
  283.  
  284.   pScreen = pWin->drawable.pScreen;
  285.   pxvs = (XvScreenPtr)pScreen->devPrivates[XvScreenIndex].ptr;
  286.  
  287.   if (!pxvs)
  288.     {
  289.       rep.type = X_Reply;
  290.       rep.sequenceNumber = client->sequence;
  291.       rep.num_adaptors = 0;
  292.       rep.length = 0;
  293.  
  294.       _WriteQueryAdaptorsReply(client, &rep);
  295.  
  296.       return Success;
  297.     }
  298.  
  299.   (* pxvs->ddQueryAdaptors)(pScreen, &pxvs->nAdaptors, &pxvs->pAdaptors);
  300.  
  301.   rep.type = X_Reply;
  302.   rep.sequenceNumber = client->sequence;
  303.   rep.num_adaptors = pxvs->nAdaptors;
  304.  
  305.   /* CALCULATE THE TOTAL SIZE OF THE REPLY IN BYTES */
  306.  
  307.   totalSize = pxvs->nAdaptors * sz_xvAdaptorInfo;
  308.  
  309.   /* FOR EACH ADPATOR ADD UP THE BYTES FOR ENCODINGS AND FORMATS */
  310.  
  311.   na = pxvs->nAdaptors;
  312.   pa = pxvs->pAdaptors;
  313.   while (na--)
  314.     {
  315.       totalSize += (strlen(pa->name) + 3) & ~3;
  316.       totalSize += pa->nFormats * sz_xvFormat;
  317.       pa++;
  318.     }
  319.  
  320.   rep.length = totalSize >> 2;
  321.  
  322.   _WriteQueryAdaptorsReply(client, &rep);
  323.  
  324.   na = pxvs->nAdaptors;
  325.   pa = pxvs->pAdaptors;
  326.   while (na--)
  327.     {
  328.  
  329.       ainfo.base_id = pa->base_id;
  330.       ainfo.num_ports = pa->nPorts;
  331.       ainfo.type = pa->type;
  332.       ainfo.name_size = strlen(pa->name);
  333.       ainfo.num_formats = pa->nFormats;
  334.  
  335.       _WriteAdaptorInfo(client, &ainfo);
  336.  
  337.       WriteToClient(client, ainfo.name_size, pa->name);
  338.  
  339.       nf = pa->nFormats;
  340.       pf = pa->pFormats;
  341.       while (nf--)
  342.     {
  343.       format.depth = pf->depth;
  344.       format.visual = pf->visual;
  345.       _WriteFormat(client, &format);
  346.       pf++;
  347.     }
  348.  
  349.       pa++;
  350.  
  351.     }
  352.  
  353.   return (client->noClientException);
  354.  
  355. }
  356.  
  357. static int
  358. ProcXvQueryEncodings(client)
  359. register ClientPtr client;
  360.  
  361. {
  362.   xvEncodingInfo einfo;
  363.   xvQueryEncodingsReply rep;
  364.   int totalSize;
  365.   XvPortPtr pPort;
  366.   int ne;
  367.   XvEncodingPtr pe;
  368.   int status;
  369.  
  370.   REQUEST(xvQueryEncodingsReq);
  371.   REQUEST_SIZE_MATCH(xvQueryEncodingsReq);
  372.  
  373.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  374.     {
  375.       client->errorValue = stuff->port;
  376.       return (_XvBadPort);
  377.     }
  378.  
  379.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  380.     {
  381.       client->errorValue = stuff->port;
  382.       return (status);
  383.     }
  384.  
  385.   rep.type = X_Reply;
  386.   rep.sequenceNumber = client->sequence;
  387.   rep.num_encodings = pPort->pAdaptor->nEncodings;
  388.  
  389.   /* FOR EACH ENCODING ADD UP THE BYTES FOR ENCODING NAMES */
  390.  
  391.   ne = pPort->pAdaptor->nEncodings;
  392.   pe = pPort->pAdaptor->pEncodings;
  393.   totalSize = ne * sz_xvEncodingInfo;
  394.   while (ne--)
  395.     {
  396.       totalSize += (strlen(pe->name) + 3) & ~3;
  397.       pe++;
  398.     }
  399.  
  400.   rep.length = totalSize >> 2;
  401.  
  402.   _WriteQueryEncodingsReply(client, &rep);
  403.  
  404.   ne = pPort->pAdaptor->nEncodings;
  405.   pe = pPort->pAdaptor->pEncodings;
  406.   do
  407.     {
  408.       einfo.encoding = pe->id;
  409.       einfo.name_size = strlen(pe->name);
  410.       einfo.width = pe->width;
  411.       einfo.height = pe->height;
  412.       einfo.rate.numerator = pe->rate.numerator;
  413.       einfo.rate.denominator = pe->rate.denominator;
  414.       _WriteEncodingInfo(client, &einfo);
  415.       WriteToClient(client, einfo.name_size, pe->name);
  416.       pe++;
  417.     } while (--ne);
  418.  
  419.   return (client->noClientException);
  420.  
  421. }
  422.  
  423. static int
  424. ProcXvPutVideo(client)
  425. register ClientPtr client;
  426.  
  427. {
  428.   register DrawablePtr pDraw;
  429.   XvPortPtr pPort;
  430.   register GCPtr pGC;
  431.   int status;
  432.  
  433.   REQUEST(xvPutVideoReq);
  434.   REQUEST_SIZE_MATCH(xvPutVideoReq);
  435.  
  436.   VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
  437.  
  438.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  439.     {
  440.       client->errorValue = stuff->port;
  441.       return (_XvBadPort);
  442.     }
  443.  
  444.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  445.     {
  446.       client->errorValue = stuff->port;
  447.       return (status);
  448.     }
  449.  
  450.   if (!(pPort->pAdaptor->type & XvInputMask))
  451.     {
  452.       client->errorValue = stuff->port;
  453.       return (BadMatch);
  454.     }
  455.  
  456.   status = XVCALL(diMatchPort)(pPort, pDraw);
  457.   if (status != Success)
  458.     {
  459.       return status;
  460.     }
  461.  
  462.   return XVCALL(diPutVideo)(client, pDraw, pPort, pGC,
  463.                 stuff->vid_x, stuff->vid_y,
  464.                 stuff->vid_w, stuff->vid_h,
  465.                 stuff->drw_x, stuff->drw_y,
  466.                 stuff->drw_w, stuff->drw_h);
  467.  
  468. }
  469.  
  470. static int
  471. ProcXvPutStill(client)
  472. register ClientPtr client;
  473.  
  474. {
  475.   register DrawablePtr pDraw;
  476.   XvPortPtr pPort;
  477.   register GCPtr pGC;
  478.   int status;
  479.  
  480.   REQUEST(xvPutStillReq);
  481.   REQUEST_SIZE_MATCH(xvPutStillReq);
  482.  
  483.   VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
  484.  
  485.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  486.     {
  487.       client->errorValue = stuff->port;
  488.       return (_XvBadPort);
  489.     }
  490.  
  491.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  492.     {
  493.       client->errorValue = stuff->port;
  494.       return (status);
  495.     }
  496.  
  497.   if (!(pPort->pAdaptor->type & XvInputMask))
  498.     {
  499.       client->errorValue = stuff->port;
  500.       return (BadMatch);
  501.     }
  502.  
  503.   status = XVCALL(diMatchPort)(pPort, pDraw);
  504.   if (status != Success)
  505.     {
  506.       return status;
  507.     }
  508.  
  509.   return XVCALL(diPutStill)(client, pDraw, pPort, pGC,
  510.                 stuff->vid_x, stuff->vid_y,
  511.                 stuff->vid_w, stuff->vid_h,
  512.                 stuff->drw_x, stuff->drw_y,
  513.                 stuff->drw_w, stuff->drw_h);
  514.  
  515. }
  516.  
  517.  
  518. static int
  519. ProcXvGetVideo(client)
  520. register ClientPtr client;
  521.  
  522. {
  523.   register DrawablePtr pDraw;
  524.   XvPortPtr pPort;
  525.   register GCPtr pGC;
  526.   int status;
  527.  
  528.   REQUEST(xvGetVideoReq);
  529.   REQUEST_SIZE_MATCH(xvGetVideoReq);
  530.  
  531.   VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
  532.  
  533.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  534.     {
  535.       client->errorValue = stuff->port;
  536.       return (_XvBadPort);
  537.     }
  538.  
  539.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  540.     {
  541.       client->errorValue = stuff->port;
  542.       return (status);
  543.     }
  544.  
  545.   if (!(pPort->pAdaptor->type & XvOutputMask))
  546.     {
  547.       client->errorValue = stuff->port;
  548.       return (BadMatch);
  549.     }
  550.  
  551.   status = XVCALL(diMatchPort)(pPort, pDraw);
  552.   if (status != Success)
  553.     {
  554.       return status;
  555.     }
  556.  
  557.   return XVCALL(diGetVideo)(client, pDraw, pPort, pGC,
  558.                 stuff->vid_x, stuff->vid_y,
  559.                 stuff->vid_w, stuff->vid_h,
  560.                 stuff->drw_x, stuff->drw_y,
  561.                 stuff->drw_w, stuff->drw_h);
  562.  
  563. }
  564.  
  565.  
  566. static int
  567. ProcXvGetStill(client)
  568. register ClientPtr client;
  569.  
  570. {
  571.   register DrawablePtr pDraw;
  572.   XvPortPtr pPort;
  573.   register GCPtr pGC;
  574.   int status;
  575.  
  576.   REQUEST(xvGetStillReq);
  577.   REQUEST_SIZE_MATCH(xvGetStillReq);
  578.  
  579.   VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
  580.  
  581.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  582.     {
  583.       client->errorValue = stuff->port;
  584.       return (_XvBadPort);
  585.     }
  586.  
  587.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  588.     {
  589.       client->errorValue = stuff->port;
  590.       return (status);
  591.     }
  592.  
  593.   if (!(pPort->pAdaptor->type & XvOutputMask))
  594.     {
  595.       client->errorValue = stuff->port;
  596.       return (BadMatch);
  597.     }
  598.  
  599.   status = XVCALL(diMatchPort)(pPort, pDraw);
  600.   if (status != Success)
  601.     {
  602.       return status;
  603.     }
  604.  
  605.   return XVCALL(diGetStill)(client, pDraw, pPort, pGC,
  606.                 stuff->vid_x, stuff->vid_y,
  607.                 stuff->vid_w, stuff->vid_h,
  608.                 stuff->drw_x, stuff->drw_y,
  609.                 stuff->drw_w, stuff->drw_h);
  610.  
  611. }
  612.  
  613. static int
  614. ProcXvSelectVideoNotify(client)
  615. register ClientPtr client;
  616.  
  617. {
  618.   register DrawablePtr pDraw;
  619.   XvPortPtr pPort;
  620.   REQUEST(xvSelectVideoNotifyReq);
  621.   REQUEST_SIZE_MATCH(xvSelectVideoNotifyReq);
  622.  
  623.   if(!(pDraw = (DrawablePtr)LOOKUP_DRAWABLE(stuff->drawable, client) ))
  624.     {
  625.       client->errorValue = stuff->drawable;
  626.       return (BadWindow);
  627.     }
  628.  
  629.   return XVCALL(diSelectVideoNotify)(client, pDraw, stuff->onoff);
  630.  
  631. }
  632.  
  633. static int
  634. ProcXvSelectPortNotify(client)
  635. register ClientPtr client;
  636.  
  637. {
  638.   int status;
  639.   XvPortPtr pPort;
  640.   REQUEST(xvSelectPortNotifyReq);
  641.   REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
  642.  
  643.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  644.     {
  645.       client->errorValue = stuff->port;
  646.       return (_XvBadPort);
  647.     }
  648.  
  649.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  650.     {
  651.       client->errorValue = stuff->port;
  652.       return (status);
  653.     }
  654.  
  655.   return XVCALL(diSelectPortNotify)(client, pPort, stuff->onoff);
  656.  
  657. }
  658.  
  659. static int
  660. ProcXvGrabPort(client)
  661. register ClientPtr client;
  662.  
  663. {
  664.   int result, status;
  665.   XvPortPtr pPort;
  666.   xvGrabPortReply rep;
  667.   REQUEST(xvGrabPortReq);
  668.   REQUEST_SIZE_MATCH(xvGrabPortReq);
  669.  
  670.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  671.     {
  672.       client->errorValue = stuff->port;
  673.       return (_XvBadPort);
  674.     }
  675.  
  676.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  677.     {
  678.       client->errorValue = stuff->port;
  679.       return (status);
  680.     }
  681.  
  682.   status = XVCALL(diGrabPort)(client, pPort, stuff->time, &result);
  683.  
  684.   if (status != Success)
  685.     {
  686.       return status;
  687.     }
  688.  
  689.   rep.type = X_Reply;
  690.   rep.sequenceNumber = client->sequence;
  691.   rep.length = 0;
  692.   rep.result = result;
  693.  
  694.   _WriteGrabPortReply(client, &rep);
  695.  
  696.   return Success;
  697.  
  698. }
  699.  
  700. static int
  701. ProcXvUngrabPort(client)
  702. register ClientPtr client;
  703.  
  704. {
  705.   int status;
  706.   XvPortPtr pPort;
  707.   REQUEST(xvGrabPortReq);
  708.   REQUEST_SIZE_MATCH(xvGrabPortReq);
  709.  
  710.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  711.     {
  712.       client->errorValue = stuff->port;
  713.       return (_XvBadPort);
  714.     }
  715.  
  716.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  717.     {
  718.       client->errorValue = stuff->port;
  719.       return (status);
  720.     }
  721.  
  722.   return XVCALL(diUngrabPort)(client, pPort, stuff->time);
  723.  
  724. }
  725.  
  726.  
  727. static int
  728. ProcXvStopVideo(client)
  729. register ClientPtr client;
  730.  
  731. {
  732.   int status;
  733.   register DrawablePtr pDraw;
  734.   XvPortPtr pPort;
  735.   REQUEST(xvStopVideoReq);
  736.   REQUEST_SIZE_MATCH(xvStopVideoReq);
  737.  
  738.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  739.     {
  740.       client->errorValue = stuff->port;
  741.       return (_XvBadPort);
  742.     }
  743.  
  744.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  745.     {
  746.       client->errorValue = stuff->port;
  747.       return (status);
  748.     }
  749.  
  750.   if(!(pDraw = LOOKUP_DRAWABLE(stuff->drawable, client) ))
  751.     {
  752.       client->errorValue = stuff->drawable;
  753.       return (BadDrawable);
  754.     }
  755.  
  756.   return XVCALL(diStopVideo)(client, pPort, pDraw);
  757.  
  758. }
  759.  
  760. static int
  761. ProcXvSetPortAttribute(client)
  762. register ClientPtr client;
  763.  
  764. {
  765.   int status;
  766.   register len;
  767.   XvPortPtr pPort;
  768.   REQUEST(xvSetPortAttributeReq);
  769.   REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
  770.  
  771.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  772.     {
  773.       client->errorValue = stuff->port;
  774.       return (_XvBadPort);
  775.     }
  776.  
  777.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  778.     {
  779.       client->errorValue = stuff->port;
  780.       return (status);
  781.     }
  782.  
  783.   if (!ValidAtom(stuff->attribute))
  784.     {
  785.       client->errorValue = stuff->attribute;
  786.       return(BadAtom);
  787.     }
  788.  
  789.   status = XVCALL(diSetPortAttribute)(client, pPort, 
  790.                     stuff->attribute, stuff->value);
  791.  
  792.   if (status == BadMatch) 
  793.       client->errorValue = stuff->attribute;
  794.   else
  795.       client->errorValue = stuff->value;
  796.  
  797.   return status;
  798.  
  799. }
  800.  
  801. static int
  802. ProcXvGetPortAttribute(client)
  803. register ClientPtr client;
  804.  
  805. {
  806.   int value;
  807.   int status;
  808.   XvPortPtr pPort;
  809.   xvGetPortAttributeReply rep;
  810.   REQUEST(xvGetPortAttributeReq);
  811.   REQUEST_SIZE_MATCH(xvGetPortAttributeReq);
  812.  
  813.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  814.     {
  815.       client->errorValue = stuff->port;
  816.       return (_XvBadPort);
  817.     }
  818.  
  819.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  820.     {
  821.       client->errorValue = stuff->port;
  822.       return (status);
  823.     }
  824.  
  825.   if (!ValidAtom(stuff->attribute))
  826.     {
  827.       client->errorValue = stuff->attribute;
  828.       return(BadAtom);
  829.     }
  830.  
  831.   status = XVCALL(diGetPortAttribute)(client, pPort, stuff->attribute, &value);
  832.   if (status != Success)
  833.     {
  834.       client->errorValue = stuff->attribute;
  835.       return status;
  836.     }
  837.  
  838.   rep.type = X_Reply;
  839.   rep.sequenceNumber = client->sequence;
  840.   rep.length = 0;
  841.   rep.value = value;
  842.  
  843.   _WriteGetPortAttributeReply(client, &rep);
  844.  
  845.   return Success;
  846. }
  847.  
  848. static int
  849. ProcXvQueryBestSize(client)
  850. register ClientPtr client;
  851.  
  852. {
  853.   int status;
  854.   unsigned int actual_width, actual_height;
  855.   XvPortPtr pPort;
  856.   xvQueryBestSizeReply rep;
  857.   REQUEST(xvQueryBestSizeReq);
  858.   REQUEST_SIZE_MATCH(xvQueryBestSizeReq);
  859.  
  860.   if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
  861.     {
  862.       client->errorValue = stuff->port;
  863.       return (_XvBadPort);
  864.     }
  865.  
  866.   if ((status = _AllocatePort(stuff->port, pPort)) != Success)
  867.     {
  868.       client->errorValue = stuff->port;
  869.       return (status);
  870.     }
  871.  
  872.   rep.type = X_Reply;
  873.   rep.sequenceNumber = client->sequence;
  874.   rep.length = 0;
  875.  
  876.   (* pPort->pAdaptor->ddQueryBestSize)(client, pPort, stuff->motion,
  877.                        stuff->vid_w, stuff->vid_h, 
  878.                        stuff->drw_w, stuff->drw_h, 
  879.                        &actual_width, &actual_height);
  880.  
  881.   rep.actual_width = actual_width;
  882.   rep.actual_height = actual_height;
  883.  
  884.   _WriteQueryBestSizeReply(client, &rep);
  885.  
  886.   return Success;
  887. }
  888.  
  889. /* Swapped Procs */
  890.  
  891. static int
  892. SProcXvQueryExtension(client)
  893. register ClientPtr client;
  894.  
  895. {
  896.   register char n;
  897.   REQUEST(xvQueryExtensionReq);
  898.   swaps(&stuff->length, n);
  899.   return ProcXvQueryExtension(client);
  900. }
  901.  
  902. static int
  903. SProcXvQueryAdaptors(client)
  904. register ClientPtr client;
  905.  
  906. {
  907.   register char n;
  908.   REQUEST(xvQueryAdaptorsReq);
  909.   swaps(&stuff->length, n);
  910.   swapl(&stuff->window, n);
  911.   return ProcXvQueryAdaptors(client);
  912. }
  913.  
  914. static int
  915. SProcXvQueryEncodings(client)
  916. register ClientPtr client;
  917.  
  918. {
  919.   register char n;
  920.   REQUEST(xvQueryEncodingsReq);
  921.   swaps(&stuff->length, n);
  922.   swapl(&stuff->port, n);
  923.   return ProcXvQueryEncodings(client);
  924. }
  925.  
  926. static int
  927. SProcXvGrabPort(client)
  928. register ClientPtr client;
  929.  
  930. {
  931.   register char n;
  932.   REQUEST(xvGrabPortReq);
  933.   swaps(&stuff->length, n);
  934.   swapl(&stuff->port, n);
  935.   swapl(&stuff->time, n);
  936.   return ProcXvGrabPort(client);
  937. }
  938.  
  939. static int
  940. SProcXvUngrabPort(client)
  941. register ClientPtr client;
  942.  
  943. {
  944.   register char n;
  945.   REQUEST(xvUngrabPortReq);
  946.   swaps(&stuff->length, n);
  947.   swapl(&stuff->port, n);
  948.   swapl(&stuff->time, n);
  949.   return ProcXvUngrabPort(client);
  950. }
  951.  
  952. static int
  953. SProcXvPutVideo(client)
  954. register ClientPtr client;
  955.  
  956. {
  957.   register char n;
  958.   REQUEST(xvPutVideoReq);
  959.   swaps(&stuff->length, n);
  960.   swapl(&stuff->port, n);
  961.   swapl(&stuff->drawable, n);
  962.   swapl(&stuff->gc, n);
  963.   swaps(&stuff->vid_x, n);
  964.   swaps(&stuff->vid_y, n);
  965.   swaps(&stuff->vid_w, n);
  966.   swaps(&stuff->vid_h, n);
  967.   swaps(&stuff->drw_x, n);
  968.   swaps(&stuff->drw_y, n);
  969.   swaps(&stuff->drw_w, n);
  970.   swaps(&stuff->drw_h, n);
  971.   return ProcXvPutVideo(client);
  972. }
  973.  
  974. static int
  975. SProcXvPutStill(client)
  976. register ClientPtr client;
  977.  
  978. {
  979.   register char n;
  980.   REQUEST(xvPutStillReq);
  981.   swaps(&stuff->length, n);
  982.   swapl(&stuff->port, n);
  983.   swapl(&stuff->drawable, n);
  984.   swapl(&stuff->gc, n);
  985.   swaps(&stuff->vid_x, n);
  986.   swaps(&stuff->vid_y, n);
  987.   swaps(&stuff->vid_w, n);
  988.   swaps(&stuff->vid_h, n);
  989.   swaps(&stuff->drw_x, n);
  990.   swaps(&stuff->drw_y, n);
  991.   swaps(&stuff->drw_w, n);
  992.   swaps(&stuff->drw_h, n);
  993.   return ProcXvPutStill(client);
  994. }
  995.  
  996. static int
  997. SProcXvGetVideo(client)
  998. register ClientPtr client;
  999.  
  1000. {
  1001.   register char n;
  1002.   REQUEST(xvGetVideoReq);
  1003.   swaps(&stuff->length, n);
  1004.   swapl(&stuff->port, n);
  1005.   swapl(&stuff->drawable, n);
  1006.   swapl(&stuff->gc, n);
  1007.   swaps(&stuff->vid_x, n);
  1008.   swaps(&stuff->vid_y, n);
  1009.   swaps(&stuff->vid_w, n);
  1010.   swaps(&stuff->vid_h, n);
  1011.   swaps(&stuff->drw_x, n);
  1012.   swaps(&stuff->drw_y, n);
  1013.   swaps(&stuff->drw_w, n);
  1014.   swaps(&stuff->drw_h, n);
  1015.   return ProcXvGetVideo(client);
  1016. }
  1017.  
  1018. static int
  1019. SProcXvGetStill(client)
  1020. register ClientPtr client;
  1021.  
  1022. {
  1023.   register char n;
  1024.   REQUEST(xvGetStillReq);
  1025.   swaps(&stuff->length, n);
  1026.   swapl(&stuff->port, n);
  1027.   swapl(&stuff->drawable, n);
  1028.   swapl(&stuff->gc, n);
  1029.   swaps(&stuff->vid_x, n);
  1030.   swaps(&stuff->vid_y, n);
  1031.   swaps(&stuff->vid_w, n);
  1032.   swaps(&stuff->vid_h, n);
  1033.   swaps(&stuff->drw_x, n);
  1034.   swaps(&stuff->drw_y, n);
  1035.   swaps(&stuff->drw_w, n);
  1036.   swaps(&stuff->drw_h, n);
  1037.   return ProcXvGetStill(client);
  1038. }
  1039.  
  1040. static int
  1041. SProcXvSelectVideoNotify(client)
  1042. register ClientPtr client;
  1043.  
  1044. {
  1045.   register char n;
  1046.   REQUEST(xvSelectVideoNotifyReq);
  1047.   swaps(&stuff->length, n);
  1048.   swapl(&stuff->drawable, n);
  1049.   return ProcXvSelectVideoNotify(client);
  1050. }
  1051.  
  1052. static int
  1053. SProcXvSelectPortNotify(client)
  1054. register ClientPtr client;
  1055.  
  1056. {
  1057.   register char n;
  1058.   REQUEST(xvSelectPortNotifyReq);
  1059.   swaps(&stuff->length, n);
  1060.   swapl(&stuff->port, n);
  1061.   return ProcXvSelectPortNotify(client);
  1062. }
  1063.  
  1064. static int
  1065. SProcXvStopVideo(client)
  1066. register ClientPtr client;
  1067.  
  1068. {
  1069.   register char n;
  1070.   REQUEST(xvStopVideoReq);
  1071.   swaps(&stuff->length, n);
  1072.   swapl(&stuff->port, n);
  1073.   swapl(&stuff->drawable, n);
  1074.   return ProcXvStopVideo(client);
  1075. }
  1076.  
  1077. static int
  1078. SProcXvSetPortAttribute(client)
  1079. register ClientPtr client;
  1080.  
  1081. {
  1082.   register char n;
  1083.   REQUEST(xvSetPortAttributeReq);
  1084.   swaps(&stuff->length, n);
  1085.   swapl(&stuff->port, n);
  1086.   swapl(&stuff->attribute, n);
  1087.   return ProcXvSetPortAttribute(client);
  1088. }
  1089.  
  1090. static int
  1091. SProcXvGetPortAttribute(client)
  1092. register ClientPtr client;
  1093.  
  1094. {
  1095.   register char n;
  1096.   REQUEST(xvGetPortAttributeReq);
  1097.   swaps(&stuff->length, n);
  1098.   swapl(&stuff->port, n);
  1099.   swapl(&stuff->attribute, n);
  1100.   return ProcXvGetPortAttribute(client);
  1101. }
  1102.  
  1103. static int
  1104. SProcXvQueryBestSize(client)
  1105. register ClientPtr client;
  1106.  
  1107. {
  1108.   register char n;
  1109.   REQUEST(xvQueryBestSizeReq);
  1110.   swaps(&stuff->length, n);
  1111.   swapl(&stuff->port, n);
  1112.   swaps(&stuff->vid_w, n);
  1113.   swaps(&stuff->vid_h, n);
  1114.   swaps(&stuff->drw_w, n);
  1115.   swaps(&stuff->drw_h, n);
  1116.   return ProcXvQueryBestSize(client);
  1117. }
  1118.  
  1119. static int
  1120. SWriteQueryExtensionReply(client, rep)
  1121. register ClientPtr client;
  1122. xvQueryExtensionReply *rep;
  1123.  
  1124. {
  1125.   register char n;
  1126.  
  1127.   swaps(&rep->sequenceNumber, n);
  1128.   swapl(&rep->length, n);
  1129.   swaps(&rep->version, n);
  1130.   swaps(&rep->revision, n);
  1131.   
  1132.   (void)WriteToClient(client, sz_xvQueryExtensionReply, (char *)&rep);
  1133.  
  1134. }
  1135.  
  1136. static int
  1137. SWriteQueryAdaptorsReply(client, rep)
  1138. register ClientPtr client;
  1139. xvQueryAdaptorsReply *rep;
  1140.  
  1141. {
  1142.   register char n;
  1143.  
  1144.   swaps(&rep->sequenceNumber, n);
  1145.   swapl(&rep->length, n);
  1146.   swaps(&rep->num_adaptors, n);
  1147.   
  1148.   (void)WriteToClient(client, sz_xvQueryAdaptorsReply, (char *)&rep);
  1149.  
  1150. }
  1151.  
  1152. static int
  1153. SWriteQueryEncodingsReply(client, rep)
  1154. register ClientPtr client;
  1155. xvQueryEncodingsReply *rep;
  1156.  
  1157. {
  1158.   register char n;
  1159.  
  1160.   swaps(&rep->sequenceNumber, n);
  1161.   swapl(&rep->length, n);
  1162.   swaps(&rep->num_encodings, n);
  1163.   
  1164.   (void)WriteToClient(client, sz_xvQueryEncodingsReply, (char *)&rep);
  1165.  
  1166. }
  1167.  
  1168. static int
  1169. SWriteAdaptorInfo(client, pAdaptor)
  1170. register ClientPtr client;
  1171. xvAdaptorInfo *pAdaptor;
  1172.  
  1173. {
  1174.   register char n;
  1175.  
  1176.   swapl(&pAdaptor->base_id, n);
  1177.   swaps(&pAdaptor->name_size, n);
  1178.   swaps(&pAdaptor->num_ports, n);
  1179.   swaps(&pAdaptor->num_formats, n);
  1180.  
  1181.   (void)WriteToClient(client, sz_xvAdaptorInfo, (char *)pAdaptor);
  1182.  
  1183. }
  1184.  
  1185. static int
  1186. SWriteEncodingInfo(client, pEncoding)
  1187. register ClientPtr client;
  1188. xvEncodingInfo *pEncoding;
  1189.  
  1190. {
  1191.   register char n;
  1192.   
  1193.   swapl(&pEncoding->encoding, n);
  1194.   swaps(&pEncoding->name_size, n);
  1195.   swaps(&pEncoding->width, n);
  1196.   swaps(&pEncoding->height, n);
  1197.   swapl(&pEncoding->rate.numerator, n);
  1198.   swapl(&pEncoding->rate.denominator, n);
  1199.   (void)WriteToClient(client, sz_xvEncodingInfo, (char *)pEncoding);
  1200. }
  1201.  
  1202. static int
  1203. SWriteFormat(client, pFormat)
  1204. register ClientPtr client;
  1205. xvFormat *pFormat;
  1206.  
  1207. {
  1208.   register char n;
  1209.  
  1210.   swapl(&pFormat->visual, n);
  1211.   (void)WriteToClient(client, sz_xvFormat, (char *)pFormat);
  1212. }
  1213.  
  1214. static int
  1215. SWriteGrabPortReply(client, rep)
  1216. register ClientPtr client;
  1217. xvGrabPortReply *rep;
  1218.  
  1219. {
  1220.   register char n;
  1221.  
  1222.   swaps(&rep->sequenceNumber, n);
  1223.   swapl(&rep->length, n);
  1224.  
  1225.   (void)WriteToClient(client, sz_xvGrabPortReply, (char *)&rep);
  1226.  
  1227. }
  1228.  
  1229. static int
  1230. SWriteGetPortAttributeReply(client, rep)
  1231. register ClientPtr client;
  1232. xvGetPortAttributeReply *rep;
  1233.  
  1234. {
  1235.   register char n;
  1236.  
  1237.   swaps(&rep->sequenceNumber, n);
  1238.   swapl(&rep->length, n);
  1239.   swapl(&rep->value, n);
  1240.  
  1241.   (void)WriteToClient(client, sz_xvGetPortAttributeReply, (char *)&rep);
  1242.  
  1243. }
  1244.  
  1245. static int
  1246. SWriteQueryBestSizeReply(client, rep)
  1247. register ClientPtr client;
  1248. xvQueryBestSizeReply *rep;
  1249.  
  1250. {
  1251.   register char n;
  1252.  
  1253.   swaps(&rep->sequenceNumber, n);
  1254.   swapl(&rep->length, n);
  1255.   swaps(&rep->actual_width, n);
  1256.   swaps(&rep->actual_height, n);
  1257.  
  1258.   (void)WriteToClient(client, sz_xvQueryBestSizeReply, (char *)&rep);
  1259.  
  1260. }
  1261.